{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 分类训练"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 机器学习的HelloWorld ，一个新的分类算法，都会看看在MNIST的上的执行结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'\\x00\\x00\\x00\\x02'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import struct\n",
    "struct.pack('>i',2) # 高位字节，把2打包成inter类型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "![jupyter](./g1.png)\n",
    "![jupyter](./g2.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2051, 60000, 28, 28)\n",
      "47040000\n"
     ]
    }
   ],
   "source": [
    "# 导入数据\n",
    "import struct\n",
    "# 从指定路径读取数据\n",
    "with open('./MNIST_data/train-images-idx3-ubyte', 'rb') as f:\n",
    "    # 内容\n",
    "    buffer = f.read(4*4) # 4个int\n",
    "    # 解析出4个int类型\n",
    "    head = struct.unpack('>iiii',buffer)\n",
    "    print(head)\n",
    "    # 读图片 像素6w*28*28\n",
    "    length = head[1] * head[2]  * head[3]\n",
    "    print(length)\n",
    "    # 像素包\n",
    "    buffer = f.read(length)\n",
    "    # 读取的字节数，B代表字节\n",
    "    data = struct.unpack('>{}B'.format(length),buffer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "47040000"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#数据长度\n",
    "len(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#数据类型\n",
    "type(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "# 将数据 转换维度   所有的图片\n",
    "imgs = np.reshape(data, (head[1], head[2], head[3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 28, 28)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imgs.shape # 6w个图片 28行 28列"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAMdUlEQVR4nO3dX6gc5R3G8eeJbRGiaDQYo02NFS9aio0lSMFQUkxDFCHxomIuSqTS40WVChUiVlAphVBri4gKp2j+lNZSiDahlKqEqC1B8SipxiapNkRNcjinIqK5SvX8enEmcoy7s8edmZ1Nft8PHHZ33t2ZH0OevO/M7M7riBCAU9+ctgsAMBiEHUiCsANJEHYgCcIOJPGFQW7MNqf+gYZFhDstr9Sz215le7/tN23fUWVdAJrlfq+z2z5N0r8lfU/SIUkvSVobEf8q+Qw9O9CwJnr2KyS9GREHIuKYpD9KWl1hfQAaVCXsF0p6Z8brQ8WyT7E9YnvM9liFbQGoqMoJuk5Dhc8M0yNiVNKoxDAeaFOVnv2QpEUzXn9Z0pFq5QBoSpWwvyTpUtsX2/6SpBskba+nLAB163sYHxEf2b5F0lOSTpP0WES8XltlAGrV96W3vjbGMTvQuEa+VAPg5EHYgSQIO5AEYQeSIOxAEoQdSIKwA0kQdiAJwg4kQdiBJAg7kARhB5Ig7EAShB1IgrADSRB2IAnCDiRB2IEkCDuQBGEHkiDsQBKEHUiCsANJEHYgCcIOJEHYgSQIO5AEYQeSIOxAEn1P2Qw07a677iptv/fee0vb58zp3pctX7689LPPPfdcafvJqFLYbR+U9KGkjyV9FBFL6ygKQP3q6Nm/GxHv1rAeAA3imB1IomrYQ9LTtl+2PdLpDbZHbI/ZHqu4LQAVVB3GXxkRR2yfJ+kZ2/si4vmZb4iIUUmjkmQ7Km4PQJ8q9ewRcaR4nJT0pKQr6igKQP36DrvtubbPPP5c0kpJe+oqDEC9qgzjF0h60vbx9fwhIv5WS1VI4cYbbyxtX79+fWn71NRU39uOyHdE2XfYI+KApG/WWAuABnHpDUiCsANJEHYgCcIOJEHYgST4iStac9FFF5W2n3766QOqJAd6diAJwg4kQdiBJAg7kARhB5Ig7EAShB1IguvsaNSKFSu6tt16662V1r1v377S9muvvbZr28TERKVtn4zo2YEkCDuQBGEHkiDsQBKEHUiCsANJEHYgCa6zo5Jly5aVtm/cuLFr21lnnVVp2/fdd19p+1tvvVVp/acaenYgCcIOJEHYgSQIO5AEYQeSIOxAEoQdSILr7Khk3bp1pe0XXHBB3+t+9tlnS9u3bNnS97oz6tmz237M9qTtPTOWnWP7GdtvFI/zmi0TQFWzGcZvkrTqhGV3SNoREZdK2lG8BjDEeoY9Ip6X9N4Ji1dL2lw83yxpTc11AahZv8fsCyJiXJIiYtz2ed3eaHtE0kif2wFQk8ZP0EXEqKRRSbIdTW8PQGf9XnqbsL1QkorHyfpKAtCEfsO+XdLxay7rJG2rpxwATXFE+cja9uOSlkuaL2lC0t2S/izpT5K+IultSd+PiBNP4nVaF8P4k8z8+fNL23vdf31qaqpr2/vvv1/62euvv760fefOnaXtWUWEOy3vecweEWu7NF1VqSIAA8XXZYEkCDuQBGEHkiDsQBKEHUiCn7gmt3jx4tL2rVu3NrbtBx98sLSdS2v1omcHkiDsQBKEHUiCsANJEHYgCcIOJEHYgSS4zp7cqlUn3kv00y677LJK69+xY0fXtgceeKDSuvH50LMDSRB2IAnCDiRB2IEkCDuQBGEHkiDsQBI9byVd68a4lfTArVlTPg3fpk2bStvnzp1b2r5r167S9rLbQfe6DTX60+1W0vTsQBKEHUiCsANJEHYgCcIOJEHYgSQIO5AEv2c/BZTd+73J+75L0oEDB0rbuZY+PHr27LYfsz1pe8+MZffYPmx7d/F3TbNlAqhqNsP4TZI63c7kNxGxpPj7a71lAahbz7BHxPOS3htALQAaVOUE3S22Xy2G+fO6vcn2iO0x22MVtgWgon7D/oikSyQtkTQu6f5ub4yI0YhYGhFL+9wWgBr0FfaImIiIjyNiStJvJV1Rb1kA6tZX2G0vnPHyOkl7ur0XwHDoeZ3d9uOSlkuab/uQpLslLbe9RFJIOijp5gZrRA/r16/v2jY1NdXotjds2NDo+lGfnmGPiLUdFj/aQC0AGsTXZYEkCDuQBGEHkiDsQBKEHUiCn7ieBJYsWVLavnLlysa2vW3bttL2/fv3N7Zt1IueHUiCsANJEHYgCcIOJEHYgSQIO5AEYQeSYMrmk8Dk5GRp+7x5Xe8K1tMLL7xQ2n711VeXth89erTvbaMZTNkMJEfYgSQIO5AEYQeSIOxAEoQdSIKwA0nwe/aTwLnnnlvaXuV20Q8//HBpO9fRTx307EAShB1IgrADSRB2IAnCDiRB2IEkCDuQBNfZh8DGjRtL2+fMae7/5F27djW2bgyXnv+KbC+yvdP2Xtuv2/5Jsfwc28/YfqN47P8OCgAaN5su4yNJP42Ir0n6tqQf2/66pDsk7YiISyXtKF4DGFI9wx4R4xHxSvH8Q0l7JV0oabWkzcXbNkta01SRAKr7XMfsthdLulzSi5IWRMS4NP0fgu3zunxmRNJItTIBVDXrsNs+Q9JWSbdFxAd2x3vafUZEjEoaLdbBDSeBlszqNK/tL2o66L+PiCeKxRO2FxbtCyWV3wIVQKt69uye7sIflbQ3In49o2m7pHWSNhSP5XP7JtZryuUVK1aUtvf6CeuxY8e6tj300EOln52YmChtx6ljNsP4KyX9QNJrtncXy+7UdMj/ZPsmSW9L+n4zJQKoQ8+wR8Q/JHU7QL+q3nIANIWvywJJEHYgCcIOJEHYgSQIO5AEP3EdgLPPPru0/fzzz6+0/sOHD3dtu/322yutG6cOenYgCcIOJEHYgSQIO5AEYQeSIOxAEoQdSIKwA0kQdiAJwg4kQdiBJAg7kARhB5Ig7EAShB1Igt+zD8C+fftK23tNm7xs2bI6y0FS9OxAEoQdSIKwA0kQdiAJwg4kQdiBJAg7kIQjovwN9iJJWySdL2lK0mhEPGD7Hkk/kvTf4q13RsRfe6yrfGMAKouIjrMuzybsCyUtjIhXbJ8p6WVJayRdL+loRPxqtkUQdqB53cI+m/nZxyWNF88/tL1X0oX1lgegaZ/rmN32YkmXS3qxWHSL7VdtP2Z7XpfPjNgesz1WqVIAlfQcxn/yRvsMSc9J+kVEPGF7gaR3JYWkn2t6qP/DHutgGA80rO9jdkmy/UVJf5H0VET8ukP7Ykl/iYhv9FgPYQca1i3sPYfxti3pUUl7Zwa9OHF33HWS9lQtEkBzZnM2fpmkv0t6TdOX3iTpTklrJS3R9DD+oKSbi5N5ZeuiZwcaVmkYXxfCDjSv72E8gFMDYQeSIOxAEoQdSIKwA0kQdiAJwg4kQdiBJAg7kARhB5Ig7EAShB1IgrADSRB2IIlBT9n8rqS3ZryeXywbRsNa27DWJVFbv+qs7aJuDQP9PftnNm6PRcTS1gooMay1DWtdErX1a1C1MYwHkiDsQBJth3205e2XGdbahrUuidr6NZDaWj1mBzA4bffsAAaEsANJtBJ226ts77f9pu072qihG9sHbb9me3fb89MVc+hN2t4zY9k5tp+x/Ubx2HGOvZZqu8f24WLf7bZ9TUu1LbK90/Ze26/b/kmxvNV9V1LXQPbbwI/ZbZ8m6d+SvifpkKSXJK2NiH8NtJAubB+UtDQiWv8Chu3vSDoqacvxqbVs/1LSexGxofiPcl5ErB+S2u7R55zGu6Hauk0zfqNa3Hd1Tn/ejzZ69iskvRkRByLimKQ/SlrdQh1DLyKel/TeCYtXS9pcPN+s6X8sA9eltqEQEeMR8Urx/ENJx6cZb3XfldQ1EG2E/UJJ78x4fUjDNd97SHra9su2R9oupoMFx6fZKh7Pa7meE/WcxnuQTphmfGj2XT/Tn1fVRtg7TU0zTNf/royIb0m6WtKPi+EqZucRSZdoeg7AcUn3t1lMMc34Vkm3RcQHbdYyU4e6BrLf2gj7IUmLZrz+sqQjLdTRUUQcKR4nJT2p6cOOYTJxfAbd4nGy5Xo+ERETEfFxRExJ+q1a3HfFNONbJf0+Ip4oFre+7zrVNaj91kbYX5J0qe2LbX9J0g2StrdQx2fYnlucOJHtuZJWavimot4uaV3xfJ2kbS3W8inDMo13t2nG1fK+a33684gY+J+kazR9Rv4/kn7WRg1d6vqqpH8Wf6+3XZukxzU9rPufpkdEN0k6V9IOSW8Uj+cMUW2/0/TU3q9qOlgLW6ptmaYPDV+VtLv4u6btfVdS10D2G1+XBZLgG3RAEoQdSIKwA0kQdiAJwg4kQdiBJAg7kMT/AR1U3JCzCjB2AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "for i in range(5):\n",
    "    # 展示前五章图片\n",
    "    plt.imshow(imgs[i], cmap = 'gray')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import fetch_mldata\n",
    "# 读取数据集内容,   读取本地 https://blog.csdn.net/qq_34022601/article/details/89645320\n",
    "mnist = fetch_mldata('mnist-original', data_home='./')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'DESCR': 'mldata.org dataset: mnist-original',\n",
       " 'COL_NAMES': ['label', 'data'],\n",
       " 'target': array([0., 0., 0., ..., 9., 9., 9.]),\n",
       " 'data': array([[0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        ...,\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mnist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* DESCR 数据集描述\n",
    "* data 包含一个数组，每个实例为一行，每个特征为一列\n",
    "* target 包含一个带有标签的数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 标签和训练数据\n",
    "X, y = mnist['data'], mnist['target']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(70000, 784)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 7w  6w的训练 1w的测试，7w个 784个数据\n",
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(70000,)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(28, 28)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 随意去一个下标\n",
    "some_digit = X[12345]\n",
    "# 784个数据，变成行和列\n",
    "some_digit_image = some_digit.reshape(28, 28)\n",
    "some_digit_image.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(some_digit_image, cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[12345]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 建立测试集和训练集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 训练集 和 测试集 训练标签，测试标签\n",
    "X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5907, 40665, 36537, ..., 46719, 16740,  8564])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将数据集合交叉洗牌，交叉验证时，每个子集合数据分布均匀，有些机器学习算法对训练实例的顺序敏感\n",
    "import numpy as np\n",
    "# 6w下标，随机排列\n",
    "shuffle_index = np.random.permutation(60000)\n",
    "shuffle_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 训练集和训练标签洗牌，然后赋值\n",
    "X_train, y_train = X_train[shuffle_index], y_train[shuffle_index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       ...,\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#查看X_train内容\n",
    "X_train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练一个二元分类器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, ..., False, False, False])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 识别数字5 ，二元分类5或者非5\n",
    "# 创建目标向量 判断true  false\n",
    "y_train_5 = (y_train == 5)\n",
    "y_train_5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False, ...,  True, False, False],\n",
       "       [False,  True, False, ..., False,  True, False],\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       ...,\n",
       "       [False, False, False, ...,  True, False, False],\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       [False, False,  True, ..., False, False, False]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# -1在这里应该可以理解为一个正整数通配符，它代替任何整数。我不知道有多少列，numpy会自动帮我计算\n",
    "y_train_5.reshape(20, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 测试集 也拿出5或者 非5\n",
    "y_test_5 = (y_test == 5) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\model_selection\\_split.py:18: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated since Python 3.3,and in 3.9 it will stop working\n",
      "  from collections import Iterable\n",
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([False])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# SGD 梯度下降 分类器， 适合非常大的数据集，独立处理训练集数据，一次一个，适合在线学习，\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "# 随机种子，每次的值一直\n",
    "sgd_clf = SGDClassifier(random_state = 5)\n",
    "# 标签为5的 数据\n",
    "sgd_clf.fit(X_train, y_train_5)\n",
    "# 预测 somedigit  我设置的1\n",
    "sgd_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 性能考核"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用交叉验证测量精度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.9571, 0.9631, 0.9564])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 评估分类器比评估回归器要困难得多\n",
    "\n",
    "# 3个折叠，正确率达到 95% 以上\n",
    "from sklearn.model_selection import cross_val_score\n",
    "# 交叉验证 cv 测试次数 \n",
    "cross_val_score(sgd_clf, X_train, y_train_5, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 把每张图都分类成 非5\n",
    "from sklearn.base import BaseEstimator\n",
    "# 估算器 ，评估非5\n",
    "class Never5Classifier(BaseEstimator):\n",
    "    def fit(self, X, y=None):\n",
    "        pass\n",
    "    def predict(self, X):\n",
    "        # 初始化 矩阵，标签就是 5或者非5\n",
    "        return np.zeros((len(X), 1), dtype=bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False],\n",
       "       [False],\n",
       "       [False],\n",
       "       ...,\n",
       "       [False],\n",
       "       [False],\n",
       "       [False]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 二维矩阵，非5评估，所以全为false\n",
    "np.zeros((len(X), 1), dtype=bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.9123 , 0.90805, 0.9086 ])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 分类器，\n",
    "never_5_clf = Never5Classifier()\n",
    "# 交叉验证\n",
    "cross_val_score(never_5_clf, X_train, y_train_5, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 准确率超过90% ，因为5的图像大约只有10%，你猜一张图不是5， 90%的时间都是正确的\n",
    "* 这说明准确率无法成为分类器的首要性能指标，特别是当理偏科数据集， 某些类比其他类更为频繁"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 混淆矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "# 评估分类器性能的更好方法是混淆矩阵\n",
    "# A类别实例被分为B类别次数\n",
    "# 想要知道分类器将数字3和数字5混淆多少次，通过混淆矩阵的5行3列\n",
    "from sklearn.model_selection import cross_val_predict\n",
    "# 预测结果\n",
    "y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 与 cross_val_score 相比\n",
    "* 同样执行交叉验证\n",
    "* 返回的不是评估分数，是每个折叠的预测\n",
    "* 每一个实例在模型预测时使用的数据，在训练期间从未见过"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[52971,  1608],\n",
       "       [  860,  4561]], dtype=int64)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "# 混淆\n",
    "confusion_matrix(y_train_5, y_train_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 行表示实际类别，列表示预测类别\n",
    "# 第一行 第一列 53272 被正确的分为 非5 ，真负类\n",
    "# 第一行 第二列 1307 被错误的分类成 5 ，假正类\n",
    "# 第二行 第一列 1077 张被错误的分为 非5， 假负类\n",
    "# 第二行 第二列 4344 张被正确的分在了5 ，真正类\n",
    "# 这种衡量方式太复杂，我们可以用更简单的指标"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[54579,     0],\n",
       "       [    0,  5421]], dtype=int64)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 实际的预测标签，完美预测  实际==预测\n",
    "y_train_perfect_predictions = y_train_5\n",
    "confusion_matrix(y_train_5, y_train_perfect_predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "## 正类预测的准确率 被称为分类器的精度\n",
    "\n",
    "\n",
    "$\n",
    "\\text{精度} = \\cfrac{TP}{TP + FP}\n",
    "$\n",
    "\n",
    "TP是真正类的数量，FP是假正类的数量\n",
    "\n",
    "\n",
    "\n",
    "$\n",
    "\\text{召回率TPR} = \\cfrac{TP}{TP + FN}\n",
    "$\n",
    "* 检测正类实例的比例\n",
    "FN是假负类的数量\n",
    "![jupyter](./zhaohui.jpg)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 精度和召回率\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7393418706435403"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import precision_score, recall_score\n",
    "# 实际标签和交叉验证的预测标签，获得精度\n",
    "precision_score(y_train_5, y_train_pred) # 4327 / 4327 + 1276"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8413576830843018"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 获得召回\n",
    "recall_score(y_train_5, y_train_pred)    #  4327 / 4327 + 1094"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 说明 检测一张图的时候，只有90%的概率是准确的，而且只有64%的数字5 被它检测出来\n",
    "# 精度和召回率合成单一指标，成为 F1 分数，谐波平均值\n",
    "# 平均值平等对待所有的值，谐波平均值会给予较低值更高的权重，只有召回率和精度都很高时，才能获得较高的F1分数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\n",
    "F_1 = \\cfrac{2}{\\cfrac{1}{\\text{precision}} + \\cfrac{1}{\\text{recall}}} = 2 \\times \\cfrac{\\text{precision}\\, \\times \\, \\text{recall}}{\\text{precision}\\, + \\, \\text{recall}} = \\cfrac{TP}{TP + \\cfrac{FN + FP}{2}}\n",
    "$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7870578084555652"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import f1_score\n",
    "# f1分数\n",
    "f1_score(y_train_5, y_train_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# F1分数对那些具有相近精度和召回率 分类器更有利，这不一定符合你的期望\n",
    "# 有时候你更关心精度，有时你能关心召回率\n",
    "# 训练一个分类器检测儿童可以放心观看的视频，你可能要求拦截了很多好的视频，低召回率，保留下来的都是安全的视频，高精度\n",
    "# 不能同时增加精度并减少召回率，反之亦然  。。高召回 低精度"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 精度/召回率权衡"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "![jupyter](./quanheng.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* SGDClassifier对每个实例基于决策函数计算一个分值，大于阀值为正类，否则为负类\n",
    "* 中间阀值右侧找到4个真正类 真5 ， 一个假正类 6， 精度为 4/5 80%\n",
    "* 在所有的6个 真正的5 中，分类器找到了4个，召回率为 4/6 67%\n",
    "* 提高阀值，向右移动，精度提高，召回降低\n",
    "* 反之阀值降低，召回提高，精度降低\n",
    "* SKlearn不可以直接设置阀值，可以访问决策分数，\n",
    "* SGDClassifier 默认阀值为0 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 如何设置阀值\n",
    "\n",
    "# 用predict_proba得到每个实例属于正类的概率，然后对概率切一下。以LogisticRegression为例\n",
    "# clf = LogisticRegression()\n",
    "# clf.fit(X_train, y_train)\n",
    "# pred_proba = clf.predict_proba(X_test)[:, 1]\n",
    "# threshold = 0.75  # 阀值设置为0.75\n",
    "# pred_label = pred_proba > threshold\n",
    "\n",
    "# pred_proba是每个实例为真的概率\n",
    "# 假设阈值是0.75\n",
    "# pred_label里True就是概率大于0.75的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-161454.23328309])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 返回决策值decision_function  决策值分数\n",
    "y_scores = sgd_clf.decision_function([some_digit])\n",
    "y_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 默认阈值为0\n",
    "threshold = 0\n",
    "y_some_digit_pred = (y_scores > threshold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_some_digit_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 提高阀值可以降低召回率，提高阀值到200000，就错了这个图\n",
    "threshold = 200000\n",
    "y_some_digit_pred = (y_scores > threshold)\n",
    "y_some_digit_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "# 如何决定使用什么阀值\n",
    "# 返回决策值，而不是预测结果\n",
    "y_scores = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3,\n",
    "                             method=\"decision_function\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000,)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 有了y_scores，可以计算所有可能的阀值的精度和召回率\n",
    "y_scores.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import precision_recall_curve\n",
    "# 计算 精度 召回 阈值\n",
    "precisions, recalls, thresholds = precision_recall_curve(y_train_5, y_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用matplotlib 绘制精度和召回相对于阀值的函数图\n",
    "def plot_precision_recall_vs_threshold(precisions, recalls, thresholds):\n",
    "    plt.plot(thresholds, precisions[:-1], \"b--\", label=\"Precision\", linewidth=2)\n",
    "    plt.plot(thresholds, recalls[:-1], \"g-\", label=\"Recall\", linewidth=2)\n",
    "    plt.xlabel(\"Threshold\", fontsize=16)\n",
    "    plt.legend(loc=\"upper left\", fontsize=16)\n",
    "    plt.ylim([0, 1])\n",
    "\n",
    "plt.figure(figsize=(8, 4))\n",
    "plot_precision_recall_vs_threshold(precisions, recalls, thresholds)\n",
    "plt.xlim([-700000, 700000])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "def plot_precision_vs_recall(precisions, recalls):\n",
    "    plt.plot(recalls, precisions, \"b-\", linewidth=2)\n",
    "    plt.xlabel(\"召回\", fontsize=16)\n",
    "    plt.ylabel(\"精度\", fontsize=16)\n",
    "    plt.axis([0, 1, 0, 1])\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "plot_precision_vs_recall(precisions, recalls)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 通过选择阀值来实现最佳的精度/召回率权衡"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 目标设定为90%的精度，阀值大概在150000左右 , 设置了阀值为150000\n",
    "y_train_pred_90 = (y_scores >150000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9267817371937639"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "precision_score(y_train_5, y_train_pred_90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6140933407120458"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5, y_train_pred_90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "* 获得了一个90%精度的分类器，但如果召回太低，精度再高，也不怎么有用\n",
    "* 如果工作中，需要99%的精度，你应该回应，召回率是多少？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ROC 曲线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 本质是 真正类率tpr和假正类率fpr（错误的分为正类的负类实例比例）\n",
    "# 与召回/精度曲线非常相似"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_curve\n",
    "# 真正  假正 阈值\n",
    "fpr, tpr, thresholds = roc_curve(y_train_5, y_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "def plot_roc_curve(fpr, tpr, label=None):\n",
    "    plt.plot(fpr, tpr, linewidth=2, label=label)\n",
    "    plt.plot([0, 1], [0, 1], 'k--')\n",
    "    plt.axis([0, 1, 0, 1])\n",
    "    plt.xlabel('假正类率', fontsize=16)\n",
    "    plt.ylabel('真正类率', fontsize=16)\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "plot_roc_curve(fpr, tpr)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.963745898621238"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算曲线下面积AUC，虚线是随机分类0.5到1\n",
    "from sklearn.metrics import roc_auc_score\n",
    "\n",
    "roc_auc_score(y_train_5, y_scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 召回率TPR越高，分类器的假正类FPR就越多\n",
    "* 虚线表示纯随机分类器的ROC曲线，好的分类器应该远离这条线，向左上角\n",
    "* 是使用精度/召回率 PR曲线，还是使用ROC，关键在于 正类非常少或者更关注假正类而不是假负类，选择PR，反之ROC\n",
    "* 例如：前面例子ROC曲线很不错是因为跟负类 非5 相比， 正类 数据5 数量真的很少"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练随机森林分类器，比较SGD分类器的ROC曲线和ROC AUC分数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 获取训练集中每个实例的分数\n",
    "* RandomForestClassifier 没有descision_function(),但是拥有dict_proda()方法，sklearn中分类器都有这两个中的一个\n",
    "* dict_proda返回一个矩阵，每行一个实例，每列代表一个类别的概率，比如这个图片 70%是5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\ensemble\\weight_boosting.py:29: DeprecationWarning: numpy.core.umath_tests is an internal NumPy module and should not be imported. It will be removed in a future NumPy release.\n",
      "  from numpy.core.umath_tests import inner1d\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "# 随机森林分类器\n",
    "forest_clf = RandomForestClassifier(n_estimators=10, random_state=42)\n",
    "# 交叉验证 交叉执行predict_proba方法 预测概率\n",
    "y_probas_forest = cross_val_predict(forest_clf, X_train, y_train_5, cv=3,\n",
    "                                    method=\"predict_proba\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0.],\n",
       "       [1., 0.],\n",
       "       [1., 0.],\n",
       "       ...,\n",
       "       [1., 0.],\n",
       "       [1., 0.],\n",
       "       [1., 0.]])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_probas_forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 绘制ROC曲线，需要决策值不是概率，直接使用正类的概率作为决策值：\n",
    "y_scores_forest = y_probas_forest[:, 1] \n",
    "# 真正  假正 阈值\n",
    "fpr_forest, tpr_forest, thresholds_forest = roc_curve(y_train_5,y_scores_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., ..., 0., 0., 0.])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_scores_forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 继承了上边的图\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.plot(fpr, tpr, \"b:\", linewidth=2, label=\"SGD\")\n",
    "plot_roc_curve(fpr_forest, tpr_forest, \"Random Forest\")\n",
    "plt.legend(loc=\"lower right\", fontsize=16)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.99241879006509"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Rand 比SGD 好很多，ROC AUC的分数也高很多\n",
    "roc_auc_score(y_train_5, y_scores_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9849190507873142"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 再看一下 精度和召回率 也很高\n",
    "y_train_pred_forest = cross_val_predict(forest_clf, X_train, y_train_5, cv=3)\n",
    "precision_score(y_train_5, y_train_pred_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8192215458402509"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5, y_train_pred_forest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "* 选择合适的指标利用交叉验证来对分类器进行评估\n",
    "* 选择满足需求的精度/召回率权衡\n",
    "* 使用ROC曲线和ROC AUC分数比较多个模型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多类别分类器\n",
    "* 尝试5 之外的检测\n",
    "* 多类别分类器 区分两个以上的类别\n",
    "* 随机森里和朴素贝叶斯可以直接处理多个类别\n",
    "* 支持向量机svm和线性分类器只可以处理二元分类器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 解决方案\n",
    "1. 将数字图片分类0到9，训练10个二元分类器，每个数字一个，检测一张图片时，获取每个分类器的决策分数，哪个最高属于哪个，称为一对多OvA\n",
    "2. 为每一对数字训练一个二元分类器，区分0，1 区分0，2 区分1，2 称为一对一OvO策略，存在N个类别，需要N*（N-1）/2个分类器，最后看哪个类别获胜最多\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 优缺点\n",
    "* OvO 只需要用到部分训练集对其必须区分两个类别进行训练\n",
    "* 对于较小训练集合OvO比较有优势， 大训练集合 OvA 速度快，所以OvA更常用，比如svm 在数据规模扩大时表现糟糕\n",
    "* sklearn 检查到使用二元分类算法进行多类别分类任务，会自动运行OvA，SVM分类器除外"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([1.])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 预测结果 二元分类器进行多次训练\n",
    "sgd_clf.fit(X_train, y_train)\n",
    "sgd_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-544656.7410685 ,  105045.11835868,  -65366.60162831,\n",
       "        -157667.02235504,  -99398.99568111, -161454.23328309,\n",
       "        -236659.58723904, -221802.90816423, -145853.94463404,\n",
       "        -277160.15626563]])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 内部实际上训练了10个二元分类器，获得图片的决策分数，然后选择了分数最高的类别\n",
    "# 返回10个分数，每个类别1个\n",
    "some_digit_scores = sgd_clf.decision_function([some_digit])\n",
    "some_digit_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 拿到分数最高的索引\n",
    "np.argmax(some_digit_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 目标类别列表会存储在classes_这个属性中，按值大小排列，分类标签\n",
    "sgd_clf.classes_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 通过索引 来拿到分类标签中对应的值\n",
    "sgd_clf.classes_[np.argmax(some_digit_scores)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用OvO策略，一对一或者一对多\n",
    "from sklearn.multiclass import OneVsOneClassifier\n",
    "# 把二元分类器，封装成 ovo\n",
    "ovo_clf = OneVsOneClassifier(SGDClassifier(max_iter=5, tol=-np.infty, random_state=42))\n",
    "# 训练\n",
    "ovo_clf.fit(X_train, y_train)\n",
    "ovo_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 多个ovo\n",
    "len(ovo_clf.estimators_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用随机森林 训练 \n",
    "forest_clf.fit(X_train, y_train)\n",
    "forest_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 1., 0., 0., 0., 0., 0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 随机森林直接将实例分为多个类别，调用predict_proba()可以获得分类器将每个实例分类为每个类别的概率列表\n",
    "forest_clf.predict_proba([some_digit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 评估分类器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.8584783 , 0.86104305, 0.88903336])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用交叉验证评估SGD的准确率\n",
    "cross_val_score(sgd_clf, X_train, y_train, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.90816837, 0.90989549, 0.9113367 ])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将输入进行简单缩放 ，可以得到准确率 90 %以上\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "# 实例化\n",
    "scaler = StandardScaler()\n",
    "# 数据缩放\n",
    "X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))\n",
    "# 再次评估\n",
    "cross_val_score(sgd_clf, X_train_scaled, y_train, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 错误分析"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 项目流程\n",
    "1. 探索数据准备的选项\n",
    "2. 尝试多个模型\n",
    "3. 选择最佳模型并用GridSearchCV对参数进行微调\n",
    "4. 尽可能自动化\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 确定了一个相对合适的模型，进一步优化，分析其错误类型\n",
    "* 查看混淆矩阵\n",
    "* 使用cross_val_predict()进行预测\n",
    "* 调用confusion_matrix()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\program files\\pyvirtual\\homework\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[5728,    2,   25,   10,   11,   54,   40,    8,   40,    5],\n",
       "       [   1, 6459,   51,   27,    5,   46,    6,   14,  121,   12],\n",
       "       [  51,   38, 5352,   99,   80,   29,   83,   59,  152,   15],\n",
       "       [  48,   42,  140, 5341,    4,  221,   34,   53,  142,  106],\n",
       "       [  19,   27,   39,    8, 5381,   10,   54,   29,   81,  194],\n",
       "       [  65,   38,   36,  189,   72, 4623,  107,   31,  163,   97],\n",
       "       [  41,   23,   45,    2,   45,  105, 5609,    5,   42,    1],\n",
       "       [  25,   18,   72,   27,   48,   12,    5, 5818,   15,  225],\n",
       "       [  46,  139,   76,  168,   17,  168,   57,   24, 5010,  146],\n",
       "       [  40,   31,   28,   87,  170,   33,    2,  213,   78, 5267]],\n",
       "      dtype=int64)"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 预测标签\n",
    "y_train_pred = cross_val_predict(sgd_clf, X_train_scaled, y_train, cv=3)\n",
    "# 实际标签和预测标签，进行混淆\n",
    "conf_mx = confusion_matrix(y_train, y_train_pred)\n",
    "conf_mx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用matplotlib的matshow 函数来查看混淆矩阵的图像表示\n",
    "plt.matshow(conf_mx, cmap = plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 看起来不错，大多数图片都在主对角线上，说明它们被正确分类\n",
    "# 数字5 看起来比较暗，说明1. 数字5图片较少  2. 分类器在数字5上执行效果不如其他数字上好\n",
    "# 假设把焦点放在错误上，为取得错误率，而不是错误绝对值，需要将混淆矩阵中每个值除以相应类别中的图片数量\n",
    "\n",
    "row_sums = conf_mx.sum(axis=1, keepdims=True)\n",
    "norm_conf_mx = conf_mx / row_sums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 用0填充对角线 只保留错误，重新绘制\n",
    "np.fill_diagonal(norm_conf_mx, 0)\n",
    "plt.matshow(norm_conf_mx, cmap=plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 每行代表实际类别，每列代表预测类别\n",
    "# 8，9列比较亮，说明许多图片被错误的分类为数字8，9\n",
    "# 类别8，9行也偏亮，说明数字8和9经常会跟其他数字混淆\n",
    "# 有些很暗，比如行1，大多数数字1都被正确的分类，一些和8混淆\n",
    "# 5和3是错误最多的"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 结论\n",
    "* 改进数字8和9的分类\n",
    "* 修正数字3和5的混淆\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 如何优化分类器\n",
    "* 尝试多收集这些数字的训练集\n",
    "* 开发一些新特征来改进分类器\n",
    "* 优化分类器算法\n",
    "* 使用pillow或opencv对图片预处理，让显示模型更突出\n",
    "* 分析单个错误"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 绘制图片\n",
    "def plot_digits(instances, images_per_row=10, **options):\n",
    "    size = 28\n",
    "    images_per_row = min(len(instances), images_per_row)\n",
    "    images = [instance.reshape(size,size) for instance in instances]\n",
    "    n_rows = (len(instances) - 1) // images_per_row + 1\n",
    "    row_images = []\n",
    "    n_empty = n_rows * images_per_row - len(instances)\n",
    "    images.append(np.zeros((size, size * n_empty)))\n",
    "    for row in range(n_rows):\n",
    "        rimages = images[row * images_per_row : (row + 1) * images_per_row]\n",
    "        row_images.append(np.concatenate(rimages, axis=1))\n",
    "    image = np.concatenate(row_images, axis=0)\n",
    "    plt.imshow(image, cmap = matplotlib.cm.binary, **options)\n",
    "    plt.axis(\"off\")\n",
    "\n",
    "\n",
    "# 查看数字3和数字5的例子\n",
    "cl_a, cl_b = 3, 5\n",
    "X_aa = X_train[(y_train == cl_a) & (y_train_pred == cl_a)]\n",
    "X_ab = X_train[(y_train == cl_a) & (y_train_pred == cl_b)]\n",
    "X_ba = X_train[(y_train == cl_b) & (y_train_pred == cl_a)]\n",
    "X_bb = X_train[(y_train == cl_b) & (y_train_pred == cl_b)]\n",
    "\n",
    "plt.figure(figsize=(8,8))\n",
    "plt.subplot(221); \n",
    "plot_digits(X_aa[:25], images_per_row=5)\n",
    "plt.subplot(222); \n",
    "plot_digits(X_ab[:25], images_per_row=5)\n",
    "plt.subplot(223);\n",
    "plot_digits(X_ba[:25], images_per_row=5)\n",
    "plt.subplot(224); \n",
    "plot_digits(X_bb[:25], images_per_row=5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 左侧两个是被分类为3的图片\n",
    "# 右侧两个是被分类为5的图片\n",
    "# 大多数错误分类的图片看起来还是非常明显的错误\n",
    "# 原因：SGD是一个线性模型，它所做就是为每个像素分配一个各个类别的权重，当它看到新的图像，将加权后的像素强度汇总，从而得到一个分数进行分类\n",
    "# 数字3和5在一部分像素位上有区别，所以分类器很容易将其弄混\n",
    "# 通过上面图像，如果书写3 的连接点左移，分类器可能将其分类为数字5，这个分类器对图像位移和旋转敏感\n",
    "# 减少混淆的方法之一，就是对图像进行预处理，确保位于中心位置并且没有旋转"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多标签分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 为每个实例产生多个类别 ，例如 照片识别多个人脸\n",
    "# 分类器经过训练可以识别小红，小白，小军，一张照片 里有 小红，小白\n",
    "# 经过分类器，应该输出[1,1,0]， 是小红，是小白，不是小军\n",
    "# 输出多个二元标签的分类系统称为多标签分类系统"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
       "           metric_params=None, n_jobs=1, n_neighbors=5, p=2,\n",
       "           weights='uniform')"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "# 7 8 9 三张\n",
    "y_train_large = (y_train >= 7)\n",
    "#奇数\n",
    "y_train_odd = (y_train % 2 == 1)\n",
    "# 合成综合数据\n",
    "y_multilabel = np.c_[y_train_large, y_train_odd]\n",
    "# 算出距离\n",
    "knn_clf = KNeighborsClassifier()\n",
    "knn_clf.fit(X_train, y_multilabel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False,  True]])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# knn支持多标签分类，不是所有的分类器都支持\n",
    "knn_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.97709"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# # 评估多标签分类器方法很多，方法之一就是测量每个标签的F1分数，或者其他二元分类器指标，然后简单平均\n",
    "# y_train_knn_pred = cross_val_predict(knn_clf, X_train, y_multilabel, cv=3)\n",
    "# f1_score(y_multilabel, y_train_knn_pred, average=\"macro\")\n",
    "0.977090"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 上面假设了所有标签都同等重要，也可以给每个标签设置一个权重（该目标标签实例的数量），设置average='weighted'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多输出分类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 例子：构建一个系统去除图片中的噪声，输入一张有噪声的图片，它将输入一张干净的数字图片，分类器输出是多个标签，一个像素一个标签，每个标签多个值0到255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 增加噪声，目标将图片还原为原始图片 创建训练集和测试集\n",
    "# 初始化 噪声 训练数据\n",
    "noise = np.random.randint(0, 100, (len(X_train), 784))\n",
    "# 加到像素\n",
    "X_train_mod = X_train + noise\n",
    "\n",
    "# 测试数据\n",
    "noise = np.random.randint(0, 100, (len(X_test), 784))\n",
    "X_test_mod = X_test + noise\n",
    "y_train_mod = X_train\n",
    "y_test_mod = X_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 随意找个图片\n",
    "some_index = 5500\n",
    "plt.subplot(121);plt.imshow(X_test_mod[some_index].reshape(28, 28), cmap = matplotlib.cm.binary)\n",
    "plt.subplot(122);plt.imshow(y_test_mod[some_index].reshape(28, 28), cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 模型训练\n",
    "knn_clf.fit(X_train_mod, y_train_mod)\n",
    "# 模型预测\n",
    "clean_digit = knn_clf.predict([X_test_mod[some_index]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 拿出图片\n",
    "plt.imshow(clean_digit.reshape(28, 28), cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
